import useVoice from "@/store/useVoice";
const useVoiceStore = useVoice();
// wx &&
//       wx.setInnerAudioOption &&
//       wx.setInnerAudioOption({
//         obeyMuteSwitch: false, // 遵循系统静音开关
//       });

let _audioDataBuffer = []; //所有接收到的二进制集合
let _preloadBuffer = []; //预加载的二进制集合
let playNum = 200; //每次播放切片数量
let source;
export let AudioContext = uni.createWebAudioContext();

export const close = () => {
  console.log("模拟close关闭了111111111");
  try {
    source?.stop();
    source = null;
    // AudioContext?.pause();
    // AudioContext?.seek(0);
  } catch {}

  // AudioContext.close().then(() => {
  //   AudioContext = null;
  // });
};

export const addArrayBuffer = (arrayBuffer) => {
  _audioDataBuffer.push(arrayBuffer);
  if (_audioDataBuffer.length > 5) playAudioStream();
};

//播放音频管理
export const playAudioStream = () => {
  console.log(AudioContext.state);
  AudioContext?.resume();
  //播放中 直接return，否则会有多好个声道一起并行播放
  if (useVoiceStore.isPlaying) return;
  useVoiceStore.isPlaying = true; // 记录是否在播放

  let floatArray;

  //实时语音 需要播放中
  if (useVoiceStore.chatType == 2) {
    useVoiceStore.recorderStatus = 3; //播放中状态
  }
  //判断预加载的数组是否有数据 如有 则直接使用预加载的已处理过的数据 可直接用于播放
  if (_preloadBuffer.length) {
    floatArray = _preloadBuffer;
  } else {
    //如不满足(比如第一次进来，预加载里没有数据),则直接从缓冲区取值，然后进行转码处理 再进行播放
    let playBuffer = _audioDataBuffer.slice(0, playNum);
    _audioDataBuffer = _audioDataBuffer.slice(playNum); // 更新缓冲区
    floatArray = initBuffer(playBuffer);
  }

  //开始播放
  onPlayBuffer(floatArray, () => {
    useVoiceStore.isPlaying = false;
    //如果缓冲区和预加载的数据都清空了
    if (_audioDataBuffer.length === 0 && _preloadBuffer.length === 0) {
      //延时再判断一次，有可能返回了1个字，念完到下一词播放前，误认为播放完成会开启录音
      setTimeout(() => {
        if (_audioDataBuffer.length === 0 && _preloadBuffer.length === 0) {
          //实时语音-播放完了 需要重置状态
          if (useVoiceStore.chatType == 2) {
            console.log("播放完了，实时语音重置状态recorderStatus为4");
            useVoiceStore.recorderStatus = 4; //开始录音
          }
        }
      }, 1000);
    } else {
      playAudioStream();
    }
  });

  //初始化预加载的数据
  initPreloadBuffer();
};
//播放音频
export const onPlayBuffer = (floatArray, callback) => {
  // 创建 AudioBuffer
  if (!AudioContext) {
    AudioContext = uni.createWebAudioContext();
  }

  const buffer = AudioContext.createBuffer(1, floatArray.length, 15000);
  buffer.copyToChannel(floatArray, 0);
  // 创建 BufferSource 并连接到输出
  source = AudioContext.createBufferSource();
  source.buffer = buffer;
  source.connect(AudioContext.destination);
  source.start(0);
  source.onended = function () {
    console.log("播放完了");
    if (callback) callback();
  };
};

//将原始的二进制处理成可播放的数据
export const initBuffer = (playBufferArr) => {
  // 将多个切片合并
  const audioBuffer = [];
  playBufferArr.forEach((chunk) => {
    const chunkArray = new Int32Array(chunk); // 假设音频数据是 32 位整型
    audioBuffer.push(...Array.from(chunkArray)); // 使用 push() 合并数组
  });

  // 将数据转换为 Float32Array 以用于播放
  const floatArray = new Float32Array(audioBuffer.length);
  for (let i = 0; i < audioBuffer.length; i++) {
    floatArray[i] = audioBuffer[i] / Math.pow(2, 31); // 将 32 位整型数据归一化
  }
  return floatArray;
};

/**
 * 预加载数据的处理
 * 判断缓冲区_audioDataBuffer是否还有数据
 * 如没有 则预加载集合清空
 * 如有 则立马处理处理放到_preloadBuffer预加载集合(放进去的是解码过的可播放的数据 不是原始buffer数组)
 */
export const initPreloadBuffer = () => {
  if (_audioDataBuffer.length == 0) {
    _preloadBuffer = [];
  } else {
    //预加载数组更新 赋值转码后的数据
    _preloadBuffer = initBuffer(_audioDataBuffer.slice(0, playNum));
    //因为下次播放取的是预加载的数据，所以此时需要把缓冲区的数据更新一下 保证不重复
    _audioDataBuffer = _audioDataBuffer.slice(playNum); // 更新缓冲区
  }
};

//模仿播放二进制 唤醒设备播放权限 解决ios静音情况下 第一次通过外放播放没有声音的问题
export const playBufferDemo = () => {
  const bufferSource = AudioContext.createBufferSource();
  const emptyBuffer = AudioContext.createBuffer(1, 1, 22050); // 创建一个非常短的空音频缓冲
  bufferSource.buffer = emptyBuffer;
  bufferSource.connect(AudioContext.destination);
  bufferSource.start(0);
};

//中断播放
export const interruptVoice = () => {
  _audioDataBuffer = [];
  _preloadBuffer = [];
  console.log("中断播放了&**********************************");
};

export default {
  close,
  addArrayBuffer,
  playAudioStream,
  onPlayBuffer,
  initBuffer,
  initPreloadBuffer,
  playBufferDemo,
  interruptVoice,
};
// export default class AudioContext {
//   constructor({} = {}) {
//     AudioContext = null;
//     _audioDataBuffer = []; //所有接收到的二进制集合
//     _preloadBuffer = []; //预加载的二进制集合
//     playNum = 200; //每次播放切片数量

//     //初始化播放器
//     init();
//   }
//   //初始化录音管理
//   init() {
//     wx &&
//       wx.setInnerAudioOption &&
//       wx.setInnerAudioOption({
//         obeyMuteSwitch: false, // 遵循系统静音开关
//       });
//     AudioContext = uni.createWebAudioContext();
//   }
//   //测试用
//   // playMp3Demo() {
//   //   const innerAudioContext = uni.createInnerAudioContext();
//   //   innerAudioContext.autoplay = true;
//   //   innerAudioContext.playbackRate = 1.5;
//   //   innerAudioContext.src = "/static/t1mm.mp3";
//   //   innerAudioContext.onPlay(() => {
//   //     console.log("开始播放");
//   //   });
//   // }

//   close() {
//     return AudioContext.close();
//   }
//   //接收arraybuffer方法
//   addArrayBuffer(arrayBuffer) {
//     _audioDataBuffer.push(arrayBuffer);
//     if (_audioDataBuffer.length > 5) playAudioStream();
//   }

//   //播放音频管理
//   playAudioStream() {
//     //播放中 直接return，否则会有多好个声道一起并行播放
//     if (useVoiceStore.isPlaying) return;
//     useVoiceStore.isPlaying = true; // 记录是否在播放

//     let floatArray;

//     //实时语音 需要播放中
//     if (useVoiceStore.chatType == 2) {
//       useVoiceStore.recorderStatus = 3; //播放中状态
//     }
//     //判断预加载的数组是否有数据 如有 则直接使用预加载的已处理过的数据 可直接用于播放
//     if (_preloadBuffer.length) {
//       floatArray = _preloadBuffer;
//     } else {
//       //如不满足(比如第一次进来，预加载里没有数据),则直接从缓冲区取值，然后进行转码处理 再进行播放
//       let playBuffer = _audioDataBuffer.slice(0, playNum);
//       _audioDataBuffer = _audioDataBuffer.slice(playNum); // 更新缓冲区
//       floatArray = initBuffer(playBuffer);
//     }

//     //开始播放
//     onPlayBuffer(floatArray, () => {
//       useVoiceStore.isPlaying = false;
//       //如果缓冲区和预加载的数据都清空了
//       if (
//         _audioDataBuffer.length === 0 &&
//         _preloadBuffer.length === 0
//       ) {
//         //延时再判断一次，有可能返回了1个字，念完到下一词播放前，误认为播放完成会开启录音
//         setTimeout(() => {
//           if (
//             _audioDataBuffer.length === 0 &&
//             _preloadBuffer.length === 0
//           ) {
//             //实时语音-播放完了 需要重置状态
//             if (useVoiceStore.chatType == 2) {
//               console.log("播放完了，实时语音重置状态recorderStatus为4");
//               useVoiceStore.recorderStatus = 4; //开始录音
//             }
//           }
//         }, 1000);
//       } else {
//         playAudioStream();
//       }
//     });

//     //初始化预加载的数据
//     initPreloadBuffer();
//   }
//   //播放音频
//   onPlayBuffer(floatArray, callback) {
//     // 创建 AudioBuffer

//     const buffer = AudioContext.createBuffer(1, floatArray.length, 15000);
//     buffer.copyToChannel(floatArray, 0);
//     // 创建 BufferSource 并连接到输出
//     const source = AudioContext.createBufferSource();
//     source.buffer = buffer;
//     source.connect(AudioContext.destination);
//     source.start(0);
//     source.onended = function () {
//       console.log("播放完了");
//       if (callback) callback();
//     };
//   }

//   //将原始的二进制处理成可播放的数据
//   initBuffer(playBufferArr) {
//     // 将多个切片合并
//     const audioBuffer = [];
//     playBufferArr.forEach((chunk) => {
//       const chunkArray = new Int32Array(chunk); // 假设音频数据是 32 位整型
//       audioBuffer.push(...Array.from(chunkArray)); // 使用 push() 合并数组
//     });

//     // 将数据转换为 Float32Array 以用于播放
//     const floatArray = new Float32Array(audioBuffer.length);
//     for (let i = 0; i < audioBuffer.length; i++) {
//       floatArray[i] = audioBuffer[i] / Math.pow(2, 31); // 将 32 位整型数据归一化
//     }
//     return floatArray;
//   }

//   /**
//    * 预加载数据的处理
//    * 判断缓冲区_audioDataBuffer是否还有数据
//    * 如没有 则预加载集合清空
//    * 如有 则立马处理处理放到_preloadBuffer预加载集合(放进去的是解码过的可播放的数据 不是原始buffer数组)
//    */
//   initPreloadBuffer() {
//     if (_audioDataBuffer.length == 0) {
//       _preloadBuffer = [];
//     } else {
//       //预加载数组更新 赋值转码后的数据
//       _preloadBuffer = initBuffer(
//         _audioDataBuffer.slice(0, playNum)
//       );
//       //因为下次播放取的是预加载的数据，所以此时需要把缓冲区的数据更新一下 保证不重复
//       _audioDataBuffer = _audioDataBuffer.slice(playNum); // 更新缓冲区
//     }
//   }

//   //模仿播放二进制 唤醒设备播放权限 解决ios静音情况下 第一次通过外放播放没有声音的问题
//   playBufferDemo() {
//     const bufferSource = AudioContext.createBufferSource();
//     const emptyBuffer = AudioContext.createBuffer(1, 1, 22050); // 创建一个非常短的空音频缓冲
//     bufferSource.buffer = emptyBuffer;
//     bufferSource.connect(AudioContext.destination);
//     bufferSource.start(0);
//   }

//   //中断播放
//   interruptVoice() {
//     _audioDataBuffer = [];
//     _preloadBuffer = [];
//     console.log("中断播放了&**********************************");
//   }
// }
